home *** CD-ROM | disk | FTP | other *** search
/ Monster Media 1994 #2 / Monster Media No. 2 (Monster Media)(1994).ISO / prog_c / ems4c.zip / EMS4C.DOC < prev    next >
Text File  |  1994-05-15  |  46KB  |  1,382 lines
  1.  
  2.  
  3.                                    EMS Library
  4.  
  5.                                 For the C Language
  6.  
  7.  
  8.                                       (EMS4C)
  9.  
  10.  
  11.  
  12.                                  USERS MANUAL
  13.  
  14.  
  15.  
  16.  
  17.  
  18.                                   Version 1.0
  19.  
  20.                                  July 24, 1993
  21.  
  22.  
  23.  
  24.  
  25.                         This software is provided as-is.
  26.                  There are no warranties, expressed or implied.
  27.  
  28.  
  29.  
  30.  
  31.                               Copyright (C) 1993
  32.                               All rights reserved
  33.  
  34.  
  35.  
  36.                               MarshallSoft Computing, Inc.
  37.                               Post Office Box 4543
  38.                               Huntsville AL 35815
  39.  
  40.                               205-881-4630 Voice / FAX
  41.                               205-880-9748 Support BBS
  42.  
  43.  
  44.                                        _______
  45.                                   ____|__     |                (R)
  46.                                --|       |    |-------------------
  47.                                  |   ____|__  |  Association of
  48.                                  |  |       |_|  Shareware
  49.                                  |__|   o   |    Professionals
  50.                                -----|   |   |---------------------
  51.                                     |___|___|    MEMBER
  52.  
  53.  
  54.  
  55.  
  56.  
  57.  
  58.  
  59.  
  60.         EMS4C Users Manual                                     Page 1
  61.                               C O N T E N T S
  62.  
  63.  
  64.  
  65.  
  66.  
  67.          Chapter                                                   Page
  68.  
  69.          1.0 Introduction..............................................3
  70.              1.1 Distribution Files....................................3
  71.              1.2 Compiling the Library.................................4
  72.              1.3 User Support..........................................4
  73.              1.4 ASP Ombudsman.........................................5
  74.              1.5 Installation..........................................5
  75.          2.0 MSDOS Memory..............................................6
  76.              2.1 Types of Memory.......................................6
  77.              2.2 Bank Switching........................................6
  78.          3.0 Example Programs..........................................7
  79.              3.1 EMS_TEST..............................................7
  80.              3.2 EMS_STAT..............................................7
  81.              3.3 The EMM4C Library.....................................7
  82.          4.0 EMS Library Functions.....................................8
  83.              4.1  emsLoaded............................................9
  84.              4.2  emsGetStatus.........................................9
  85.              4.3  emsGetFrame..........................................10
  86.              4.4  emsGetPages..........................................10
  87.              4.5  emsAllocate..........................................11
  88.              4.6  emsMapMemory.........................................12
  89.              4.7  emsRelease...........................................13
  90.              4.8  emsVersion...........................................13
  91.              4.9  emsSaveMap...........................................14
  92.              4.10 emsRestoreMap........................................14
  93.              4.11 emsGetHandles........................................15
  94.              4.12 emsOwnedPages........................................15
  95.              4.13 emsPageInfo..........................................16
  96.              4.14 emsError.............................................17
  97.          5.0 EMS4C Error Codes.........................................18
  98.          6.0 Legal Issues..............................................19
  99.              6.1 Registration..........................................19
  100.              6.2 Referral Program......................................19
  101.              6.3 License...............................................20
  102.              6.4 Warranty..............................................20
  103.          7.0 Revision History..........................................20
  104.          8.0 Other MarshallSoft Computing Products for C...............21
  105.              8.1 The Personal Communications Library for C.............21
  106.              8.2 The Personal Protocol Library for C...................21
  107.              8.3 The LZW Data Compression Library for C................22
  108.  
  109.  
  110.  
  111.  
  112.  
  113.  
  114.  
  115.  
  116.  
  117.  
  118.  
  119.  
  120.         EMS4C Users Manual                                     Page 2
  121.          1.0 Introduction
  122.  
  123.          The   EMS4C   library   implements   version   3.2   of   the  LIM
  124.          (Lotus-Intel-Microsoft) specification for expanded memory. It will
  125.          run with either version 3.2 or 4.0 of the LIM specification.
  126.  
  127.          In  order  to  use  the EMS4C library, you must have either an EMS
  128.          memory board installed,  or  have  an  expanded  memory  emulation
  129.          driver program (such as EMM386 or 386MAX) installed.
  130.  
  131.          The  EMS4C  library  provides 14 functions which allow the user to
  132.          make use of expanded memory from their programs.  Several  example
  133.          programs are also provides such as:
  134.  
  135.          EMS_STAT : Displays EMS driver status.
  136.          EMS_TEST : EMS4C library test program.
  137.  
  138.          1.1 Distribution Files
  139.  
  140.          EMS4C.H      : EMS4C prototype file.
  141.          EMS4C_S.LIB  : EMS4C small model library.
  142.          EMS4C_L.LIB  : EMS4C large model library.
  143.          EMS4C_S.MIX  : MIX Power C small model object file.
  144.          EMS_ERR.C    : Error message file.
  145.          EMS_TEST.C   : Source code for the EMS4C test program.
  146.          EMS_TEST._T_ : Borland C & Turbo C makefile for EMS_TEST.
  147.          EMS_TEST._M_ : Microsoft C makefile for EMS_TEST.
  148.          EMS_TEST._Q_ : Microsoft Quick C makefile for EMS_TEST.
  149.          EMS_STAT.C   : Source code for the EMS4C status program.
  150.          EMS_STAT._T_ : Borland C & Turbo C makefile for EMS_TEST.
  151.          EMS_STAT._M_ : Microsoft C makefile for EMS_TEST.
  152.          EMS_STAT._Q_ : Microsoft Quick C makefile for EMS_TEST.
  153.  
  154.          Registered users also receive:
  155.  
  156.          EMS4C.ASM    : Source code for EMS4C library.
  157.          EMS4C_C.LIB  : EMS4C compact model library.
  158.          EMS4C_M.LIB  : EMS4C medium model library.
  159.          EMS4C_C.MIX  : MIX EMS4C compact model object.
  160.          EMS4C_L.MIX  : MIX EMS4C large model object.
  161.          MAKE_S.BAT   : Makes EMS4C_S.LIB from source.
  162.          MAKE_M.BAT   : Makes EMS4C_M.LIB from source.
  163.          MAKE_C.BAT   : Makes EMS4C_C.LIB from source.
  164.          MAKE_L.BAT   : Makes EMS4C_L.LIB from source.
  165.          MAKE_XS.BAT  : Makes EMS4C_S.MIX from source.
  166.          MAKE_XC.BAT  : Makes EMS4C_C.MIX from source.
  167.          MAKE_XL.BAT  : Makes EMS4C_L.MIX from source.
  168.  
  169.  
  170.  
  171.  
  172.  
  173.  
  174.  
  175.  
  176.  
  177.  
  178.  
  179.  
  180.         EMS4C Users Manual                                     Page 3
  181.          1.2 Compiling the Library
  182.  
  183.  
  184.          The registered user can re-assemble the source code  (source  code
  185.          is  provided in the registered version only) for the library using
  186.          one of the provided batch files ( MAKE_S.BAT,  etc.).   Note  that
  187.          you will need a Microsoft compatible assembler such as MASM.EXE in
  188.          order to create new EMS library files.
  189.  
  190.          Makefiles  are  provided  for  re-assembling  the  libraries.  For
  191.          example, to create EMS4C_S.LIB, type:
  192.  
  193.                MAKE_S
  194.  
  195.  
  196.          1.3 User Support
  197.  
  198.  
  199.          We  want you to be successful in developing your application using
  200.          our libraries! We depend on our customers to let us know what they
  201.          need in a library.  This means we are committed to  providing  the
  202.          best  libraries  that  we  can.   If  you  have any suggestions or
  203.          comments, please write to us or give us a call.
  204.  
  205.          If  you  are having a problem using EMS4C or any of our libraries,
  206.          call (205) 881-4630 between 5 PM  and  9  PM  CST  Monday  through
  207.          Friday.  You can call at other times and leave a message, and call
  208.          back  later during our regular business hours for a reply. You can
  209.          also FAX us at this same number at any time.
  210.  
  211.          You  may  also  call our 24 hour BBS (2400 baud, no parity, 8 data
  212.          bits, 1 stop bit) at any time.  The BBS will  contain  the  latest
  213.          shareware version of EMS4C, messages, and other related files. All
  214.          files  are  in standard ZIP format. You can leave a message on the
  215.          BBS, and we will usually have a reply  ready  for  you  within  24
  216.          hours.   The dedicated telephone number is 205-880-9748.  Set your
  217.          modem for 1200 to 9600 baud, 8 data bits, no parity, one stop bit.
  218.  
  219.          The  MarshallSoft  Computing,  Inc.   newsletter  "Comm  Talk"  is
  220.          published quarterly.  It discusses various communications problems
  221.          and  solutions using PCL4C (the communications library) as well as
  222.          related information such as data compression  issues.   Registered
  223.          users  receive  a  one  year complimentary subscription when first
  224.          registering and for each update purchased.   Additional  one  year
  225.          subscriptions  are  $15  plus $5 for overseas postage (postpaid in
  226.          the US).
  227.  
  228.  
  229.  
  230.  
  231.  
  232.  
  233.  
  234.  
  235.  
  236.  
  237.  
  238.  
  239.  
  240.         EMS4C Users Manual                                     Page 4
  241.          1.4 ASP Ombudsman
  242.  
  243.  
  244.          MarshallSoft  Computing,  Inc.  is  a member of the Association of
  245.          Shareware Professionals (ASP).  ASP wants to make  sure  that  the
  246.          shareware principle works for you.  If you are unable to resolve a
  247.          shareware-related  problem  with  an  ASP member by contacting the
  248.          member directly, ASP may be able to help. The  ASP  Ombudsman  can
  249.          help you resolve a dispute or problem with an ASP member, but does
  250.          not provide technical support for members' products.  Please write
  251.          to  the  ASP  Ombudsman  at  545  Grover  Road,  Muskegon,  MI USA
  252.          49442-9427, Fax 616-788-2765, or send  a  CompuServe  message  via
  253.          CompuServe Mail to ASP Ombudsman 70007,3536.
  254.  
  255.  
  256.          1.5 Installation
  257.  
  258.  
  259.          (1)  Microsoft C, Borland & Turbo C, and MIX Power C compilers are
  260.          supported. However, the code should work with most any C compiler.
  261.          Before installation of EMS4C, your C compiler  should  already  be
  262.          installed  on your system and tested. If you are not familiar with
  263.          makefiles, refer to your compiler manual. If  you  are  using  the
  264.          interactive environment for Quick C or Turbo C, be sure to compile
  265.          with the memory model corresponding to the EMS4C library used.
  266.  
  267.          (2) Make a backup  copy  of  your  distribution  disk.   Put  your
  268.          original distribution disk in a safe place.
  269.  
  270.          (3)  Create  a  work  directory  on  your work disk (normally your
  271.          harddisk). For example, to create a work directory named EMS4C, we
  272.          first log onto the work disk and then type:
  273.  
  274.                                MKDIR EMS4C
  275.  
  276.          (4)  Copy  all the files from your backup copy of the distribution
  277.          disk to your work directory.  For example, to  copy  from  the  A:
  278.          drive to your work directory, we type:
  279.  
  280.                               CD EMS4C
  281.                               COPY A:*.*
  282.  
  283.          (5)   Compile   EMS_STAT.C   and  EMS_TEST.C  and  link  with  the
  284.          appropriate EMS4C library For example, to make EMS_TEST.EXE:
  285.  
  286.              a) Borland Turbo C: Type
  287.  
  288.                   MAKE -fEMS_TEST._T_
  289.  
  290.              b) Microsoft C: Type
  291.  
  292.                   MAKE EMS_TEST._M_
  293.  
  294.              c) Quick C: Type
  295.  
  296.                   MAKE EMS_TEST._Q_
  297.  
  298.              d) MIX Power C: Type
  299.  
  300.         EMS4C Users Manual                                     Page 5
  301.  
  302.                   X_TEST_T
  303.  
  304.  
  305.  
  306.  
  307.  
  308.  
  309.  
  310.  
  311.  
  312.  
  313.  
  314.  
  315.  
  316.  
  317.  
  318.  
  319.  
  320.  
  321.  
  322.  
  323.  
  324.  
  325.  
  326.  
  327.  
  328.  
  329.  
  330.  
  331.  
  332.  
  333.  
  334.  
  335.  
  336.  
  337.  
  338.  
  339.  
  340.  
  341.  
  342.  
  343.  
  344.  
  345.  
  346.  
  347.  
  348.  
  349.  
  350.  
  351.  
  352.  
  353.  
  354.  
  355.  
  356.  
  357.  
  358.  
  359.  
  360.         EMS4C Users Manual                                     Page 6
  361.          2.0 MSDOS Memory
  362.  
  363.          2.1 Types of Memory
  364.  
  365.          Your  system  can  have  three  kinds  of  memory:   Conventional,
  366.          extended, and expanded.
  367.  
  368.          All computers have "conventional" memory which includes all memory
  369.          up  to  640KB,  also known as "lower" DOS memory. The memory above
  370.          640KB to 1MB (1024KB) is known as "upper"  DOS  memory,  which  is
  371.          used  by  MSDOS  for  device  driver, video buffers, etc. Programs
  372.          running under MSDOS can address all memory up to 1MB.
  373.  
  374.          Extended  memory  is  available  on  80286 systems and up.  To use
  375.          extended memory, you must install an extended-memory manager  such
  376.          as  HIMEM.SYS  (distributed with MSDOS 5.0 & up).  Extended memory
  377.          can also be converted to expanded memory as explained below.
  378.  
  379.          The last type of memory on MSDOS  systems  is  "expanded"  memory.
  380.          Two  kinds  of  expanded  memory exists, both of which are handled
  381.          identically by EMS4C.  The first type of  expanded  memory  is  an
  382.          expanded memory board that you install in your computer.  Expanded
  383.          memory  boards  can  be installed in any IBM PC beginning with the
  384.          8088 processor. Refer to the directions that came with your board.
  385.  
  386.          The  second type of expanded memory is really extended memory that
  387.          has  been  converted  to  expanded  memory  by  a  expanded-memory
  388.          emulator such as EMM386 (distributed with MSDOS 5.0 & up), 386MAX,
  389.          etc.  Expanded  memory  created  from  extended  memory behaves in
  390.          exactly the same way as true expanded memory.
  391.  
  392.          2.1 Bank Switching
  393.  
  394.          Expanded  memory is implemented by a technique where more than 1MB
  395.          can be used by MSDOS programs, which are limited to addressing 1MB
  396.          of memory.  This is done by a technique called "bank switching" in
  397.          which up to 32MB (in EMS 4.0) can be  referenced  in  16KB  blocks
  398.          within the 1st 1MB of memory.
  399.  
  400.          The  expanded memory is organized into contiguous 16KB pages, which
  401.          can be mapped into any of four contiguous 16KB page frames located
  402.          somewhere between 640KB and 1024KB. The mapping is  controlled  by
  403.          the EMS driver using interrupt 67H.
  404.  
  405.          The EMS4C library provides the interface necessary to perform this
  406.          bank switching from within your C program.
  407.  
  408.  
  409.  
  410.  
  411.  
  412.  
  413.  
  414.  
  415.  
  416.  
  417.  
  418.  
  419.  
  420.         EMS4C Users Manual                                     Page 7
  421.          3.0 Example Programs
  422.  
  423.  
  424.          Two example programs are provided.  Each example program should be
  425.          compiled  with  the provided makefile.  These example programs are
  426.          meant to demonstrate various ways in  which  the  EMS  compression
  427.          library can be used.
  428.  
  429.          If you are using an integrated  compiler  environment  instead  of
  430.          makefiles,  notice  that  each  program is compiled with the SMALL
  431.          memory model.
  432.  
  433.          3.1 EMS_STAT
  434.  
  435.          EMS_STAT  will  display  all EMS parameters (such as the amount of
  436.          EMS memory available) on your system.
  437.  
  438.          To run EMS_STAT, just type:
  439.  
  440.              EMS_STAT
  441.  
  442.          3.2 EMS_TEST
  443.  
  444.          The EMS_TEST program tests each of the  EMS4C  library  functions.
  445.          The  program  also  exercises  the memory mapping calls, verifying
  446.          that all mapping is performed without data loss.
  447.  
  448.          To run EMS_TEST, just type:
  449.  
  450.             EMS_TEST
  451.  
  452.          3.3 The EMM4C Library
  453.  
  454.          The EMM4C (Expanded Memory  Manager  for  C  Library)  library  is
  455.          provided  as a final example of using the EMS4C library. The EMM4C
  456.          library implements memory allocation and  de-allocation  functions
  457.          for  EMS  memory  similiar  to  the  standard  C  runtime  library
  458.          functions malloc() and free().
  459.  
  460.          There is also a EMM4C test driver provided with the EMM4C  library
  461.          that   exercises  the  EMM4C  functions.  The  EMM4C  test  driver
  462.          (EMM_TEST) operates similiarly to the EMS4C test driver.
  463.  
  464.          The  EMM4C  library  is  documented  in  the  EMM4C.DOC  file.   A
  465.          registered  version of the EMM4C library is provided when the user
  466.          registers the EMS4C library.
  467.  
  468.  
  469.  
  470.  
  471.  
  472.  
  473.  
  474.  
  475.  
  476.  
  477.  
  478.  
  479.  
  480.         EMS4C Users Manual                                     Page 8
  481.          4.0 EMS Library Functions
  482.  
  483.  
  484.          There are 14 functions in the EMS4C library.
  485.  
  486.          emsLoaded      Verifies that an expanded memory driver is loaded.
  487.          emsGetStatus   Verifies that EMS hardware (if installed) is OK.
  488.          emsGetFrame    Returns the address of the 1st EMS frame.
  489.          emsGetPages    Gets the # free pages & the total # pages.
  490.          emsAllocate    Allocates requested EMS pages.
  491.          emsMapMemory   Maps an EMS page to a page frame.
  492.          emsRelease     Release previously allocated EMS pages.
  493.          emsVersion     Gets EMS driver (EMM) version.
  494.          emsSaveMap     Saves EMS mapping context.
  495.          emsRestoreMap  Restores a previous saved EMS mapping context.
  496.          emsGetHandles  Get number of active EMS handles.
  497.          emsOwnedPages  Returns the number of pages owned by a handle.
  498.          emsPageInfo    Returns handles & pages for all handles.
  499.          emsPageMap     Gets or sets EMS page-mapping registers.
  500.  
  501.          All  error  codes  returned by EMS4C are those returned by the EMS
  502.          driver, except for error codes 0xA0, 0xA1, and 0xA2.
  503.  
  504.          This library should only be used with  EMS  version  3.2  or  4.0.
  505.          Earlier versions of the EMS may not work properly.
  506.  
  507.  
  508.  
  509.  
  510.  
  511.  
  512.  
  513.  
  514.  
  515.  
  516.  
  517.  
  518.  
  519.  
  520.  
  521.  
  522.  
  523.  
  524.  
  525.  
  526.  
  527.  
  528.  
  529.  
  530.  
  531.  
  532.  
  533.  
  534.  
  535.  
  536.  
  537.  
  538.  
  539.  
  540.         EMS4C Users Manual                                     Page 9
  541.                              4.1 emsLoaded
  542.  
  543.  
  544.         Function:    Verifies that an expanded memory driver is loaded.
  545.  
  546.           Syntax:    int emsLoaded(void);
  547.  
  548.           Remarks:   You must  call  emsLoaded  before  any  other  EMS4C
  549.                      function  in order to verify that an expanded-memory
  550.                      driver is loaded.
  551.  
  552.          Returns:    0   : No error.
  553.                      0xa0: EMS driver not loaded.
  554.                      0xa1: Illegal library modification. (Shareware only).
  555.  
  556.           Example:      /* is EMS driver loaded ? */
  557.                        Code = emsLoaded();
  558.                        if( Code != 0 )
  559.                            {/* error returned ! */
  560.                             printf("emsLoaded returns %x\n",Code);
  561.                             ...
  562.                            }
  563.  
  564.          See Also    emsGetStatus
  565.  
  566.  
  567.                              4.2 emsGetStatus
  568.  
  569.  
  570.         Function:    Verifies that EMS hardware (if installed) is OK.
  571.  
  572.           Syntax:    int emsGetStatus(void);
  573.  
  574.          Remarks:    The   emsGetStatus()   function   should  be  called
  575.                      immediately after call emsLoaded().
  576.  
  577.          Returns:    0x00: No error.
  578.                      0x80: Internal error in EMS software.
  579.                      0x81: Malfunction in EMS hardware.
  580.                      0x84: Undefined function.
  581.  
  582.          Example:    /* check EMS driver status */
  583.                      Code = emsGetStatus();
  584.                      if( Code != 0 )
  585.                         {/* error returned ! */
  586.                          printf("emsGetStatus returns %x\n",Code);
  587.                          ...
  588.                         }
  589.  
  590.          See Also    emsLoaded.
  591.  
  592.  
  593.  
  594.  
  595.  
  596.  
  597.  
  598.  
  599.  
  600.         EMS4C Users Manual                                     Page 10
  601.                              4.3 emsGetFrame
  602.  
  603.  
  604.         Function:  Returns the address of the 1st EMS frame.
  605.  
  606.           Syntax:  int emsGetFrame(SegmentP)
  607.                        int *SegmentP;    /* pointer to segment of page frame */
  608.  
  609.          Remarks:    The emsGetFrame() function is used to get the  segment
  610.                      address  of the first page frame. The four page frames
  611.                      are all 16KB  (16,384)  bytes  in  length  and  occupy
  612.                      contigous space in the area between 640KB and 1MB.
  613.  
  614.          Returns:    0x00: No error.
  615.                      0x80: Internal error in EMS software.
  616.                      0x81: Malfunction in EMS hardware.
  617.                      0x84: Undefined function.
  618.  
  619.          Example:    /* get the frame segment */
  620.                      int SegmentP;
  621.                      Code := emsGetFrame(&SegmentP);
  622.                      printf("Frame 0 address is at %x:0000\n",SegmentP);
  623.  
  624.  
  625.                              4.4 emsGetPages
  626.  
  627.  
  628.         Function:    Gets the # free pages & the total # pages.
  629.  
  630.           Syntax:    int emsGetPages(FreePagesP,TotalPagesP)
  631.                      int *FreePagesP;   /* pointer to # of free pages */
  632.                      int *TotalPagesP;  /* pointer to # of total pages */
  633.  
  634.          Remarks:     The  emsGetPages  function gets the nummber of system
  635.                      wide unallocated (free)  pages,  and  also  the  total
  636.                      number of pages. You may subsequently allocate no more
  637.                      than  the  number  of  free  pages  reported  by  this
  638.                      function.
  639.  
  640.          Returns:    0x00: No error.
  641.                      0x80: Internal error in EMS software.
  642.                      0x81: Malfunction in EMS hardware.
  643.                      0x84: Undefined function.
  644.  
  645.          Example:    /* get  # free and total pages */
  646.                      int Code;
  647.                      int FreePages;
  648.                      int TotalPages;
  649.                      ...
  650.                      Code = emsGetPages(&FreePages,&TotalPages);
  651.  
  652.          See Also    emsAllocate
  653.  
  654.  
  655.  
  656.  
  657.  
  658.  
  659.  
  660.         EMS4C Users Manual                                     Page 11
  661.                              4.5 emsAllocate
  662.  
  663.  
  664.         Function:    Allocates requested EMS pages.
  665.  
  666.           Syntax:    int emsAllocate(NumberPages,HandleP)
  667.                      int NumberPages;  /* number of pages to allocate */
  668.                      int *HandleP;     /* pointer to handle */
  669.  
  670.          Remarks:    The emsAllocated function  attempts  to  allocate  the
  671.                      requested  number  of pages, which must be less tna or
  672.                      equal to  the  number  of  free  pages  as  return  by
  673.                      emsGetPages.  The  Handle  (returned) must be used for
  674.                      subsequent calls to the remaining EMS functions.
  675.  
  676.          Returns:    0x00: No error.
  677.                      0x80: Internal error in EMS software.
  678.                      0x81: Malfunction in EMS hardware.
  679.                      0x84: Undefined function.
  680.                      0x85: No more handles available.
  681.                      0x87: Logical pages not available.
  682.                      0x88: Logical pages not currently available.
  683.                      0x89: Zero pages requested.
  684.  
  685.          Example:    /* get  # free and total pages */
  686.                      int Code;
  687.                      int NumberPages;
  688.                      int Handle;
  689.                      ...
  690.                      Code = emsAllocate(&NumberPages,&Handle);
  691.  
  692.          See Also    emsGetPages, emsRelease.
  693.  
  694.  
  695.  
  696.  
  697.  
  698.  
  699.  
  700.  
  701.  
  702.  
  703.  
  704.  
  705.  
  706.  
  707.  
  708.  
  709.  
  710.  
  711.  
  712.  
  713.  
  714.  
  715.  
  716.  
  717.  
  718.  
  719.  
  720.         EMS4C Users Manual                                     Page 12
  721.                              4.6 emsMapMemory
  722.  
  723.  
  724.         Function:    Maps an EMS page to a page frame.
  725.  
  726.           Syntax:    int emsMapMemory(PhysicalPage,LogicalPage,Handle)
  727.                      int PhysicalPage;    /* Physical page (frame) number (0-3) */
  728.                      int LogicalPage;     /* Logical page number */
  729.                      int Handle;          /* EMS handle */
  730.  
  731.          Remarks:    The emsMapMemory function maps the requested  page  to
  732.                      the  the  requested  frame.  Once  the  page  has been
  733.                      successfully mapped, you may address the  contents  of
  734.                      the page at the frame addresss.
  735.  
  736.          Returns:    0x00: No error.
  737.                      0x80: Internal error in EMS software.
  738.                      0x81: Malfunction in EMS hardware.
  739.                      0x83: Invalid handle.
  740.                      0x84: Undefined function.
  741.                      0x8a: Logical page not assigned to this handle.
  742.                      0x8b: Physical page number invalid.
  743.  
  744.          Example:    /* map memory */
  745.                      int Page;
  746.                      int Frame;
  747.                      int Handle;
  748.                      ...
  749.                      Code = emsMapMemory(Page,Frame,Handle);
  750.  
  751.          See Also    emsAllocate().
  752.  
  753.  
  754.  
  755.  
  756.  
  757.  
  758.  
  759.  
  760.  
  761.  
  762.  
  763.  
  764.  
  765.  
  766.  
  767.  
  768.  
  769.  
  770.  
  771.  
  772.  
  773.  
  774.  
  775.  
  776.  
  777.  
  778.  
  779.  
  780.         EMS4C Users Manual                                     Page 13
  781.                              4.7 emsRelease
  782.  
  783.  
  784.         Function:    Release previously allocated EMS pages.
  785.  
  786.           Syntax:    int emsRelease(Handle)
  787.                      int Handle;          /* EMS handle */
  788.  
  789.          Remarks:    The  emsRelease  function  releases memory previously
  790.                      allocated with emsAllocate(). Once memory is released,
  791.                      you can no longer reference it through the page frame.
  792.  
  793.          Returns:    0x00: No error.
  794.                      0x80: Internal error in EMS software.
  795.                      0x81: Malfunction in EMS hardware.
  796.                      0x83: Invalid handle.
  797.                      0x84: Undefined function.
  798.                      0x86: Error in mapping context.
  799.  
  800.          Example:    /* release memory */
  801.                      int Handle;
  802.                      ...
  803.                      Code = emsRelease(Handle);
  804.  
  805.          See Also    emsAllocate().
  806.  
  807.  
  808.                              4.8 emsVersion
  809.  
  810.  
  811.         Function:    Gets EMS driver (EMM) version.
  812.  
  813.           Syntax:    int emsVersion(VersionP)
  814.                      int *Version;       /* pointer to version number */
  815.  
  816.          Remarks:    The emsVersion function  returns the  Expanded  Memory
  817.                      Manager (EMM). The EMS4C library supports versions 3.2
  818.                      and 4.0 (the two most recent as of this date).
  819.  
  820.          Returns:    0x00: No error.
  821.                      0x80: Internal error in EMS software.
  822.                      0x81: Malfunction in EMS hardware.
  823.                      0x84: Undefined function.
  824.  
  825.          Example:    /* get EMM version # */
  826.                      int Version;
  827.                      int Code;
  828.                      Code = emsVersion(&Version);
  829.  
  830.  
  831.  
  832.  
  833.  
  834.  
  835.  
  836.  
  837.  
  838.  
  839.  
  840.         EMS4C Users Manual                                     Page 14
  841.                              4.9 emsSaveMap
  842.  
  843.  
  844.         Function:    Saves EMS mapping context.
  845.  
  846.           Syntax:    int emsSaveMap(Handle)
  847.                      int Handle;          /* EMS handle */
  848.  
  849.          Remarks:     The emsSaveMap function saves the current EMS mapping
  850.                      context. You will only need to call this  function  if
  851.                      you  are  writing  a  memory resident (TSR)program, an
  852.                      interrupt service routine  (ISR),  device  driver,  or
  853.                      other  code that will have to share the EMS with other
  854.                      programs at runtime.
  855.  
  856.          Returns:    0x00: No error.
  857.                      0x80: Internal error in EMS software.
  858.                      0x81: Malfunction in EMS hardware.
  859.                      0x83: Invalid handle.
  860.                      0x84: Undefined function.
  861.                      0x8c: Page-mapping hardware state save area full.
  862.                      0x8d: Mapping context already associated.
  863.  
  864.          Example:    /* save mapping context */
  865.                      int Handle;
  866.                      int Code;
  867.                      Code = emsSaveMap(Handle);
  868.  
  869.          See Also    emsRestoreMap
  870.  
  871.  
  872.                              4.10 emsRestoreMap
  873.  
  874.  
  875.         Function:    Restores a previous saved EMS mapping context.
  876.  
  877.           Syntax:    int emsRestoreMap(Handle)
  878.                      int Handle;          /* EMS handle */
  879.  
  880.          Remarks:    The emsRestoreMap() function  restores  the  mapping
  881.                      context  previously saved with emsSaveMap(). Note that
  882.                      at most one mapping context can be saved  at  any  one
  883.                      time. Refer to the emsSaveMap() function.
  884.  
  885.          Returns:    0x00: No error.
  886.                      0x80: Internal error in EMS software.
  887.                      0x81: Malfunction in EMS hardware.
  888.                      0x83: Invalid handle.
  889.                      0x84: Undefined function.
  890.                      0x8e: Save area has no context for handle.
  891.  
  892.          Example:    /* restore mapping context */
  893.                      int Handle;
  894.                      int Code;
  895.                      Code = emsRestoreMap(Handle);
  896.  
  897.          See Also    emsSaveMap
  898.  
  899.  
  900.         EMS4C Users Manual                                     Page 15
  901.                              4.11 emsActiveHandles
  902.  
  903.         Function:    Get number of active EMS handles.
  904.  
  905.           Syntax:    int emsActiveHandles(HandlesP)
  906.                      int *HandlesP;     /* pointer to number of handles */
  907.  
  908.          Remarks:     The  emsActiveHandles()  function  gets the number of
  909.                      active  EMS  handles  already  allocated.  If   0   is
  910.                      reported,  then  EMS  is not in use. There is a system
  911.                      wide maximum of 255 handles.
  912.  
  913.          Returns:    0x00: No error.
  914.                      0x80: Internal error in EMS software.
  915.                      0x81: Malfunction in EMS hardware.
  916.                      0x83: Invalid handle.
  917.                      0x84: Undefined function.
  918.  
  919.          Example:    /* report # free EMS handles */
  920.                      int Code;
  921.                      int Handles;
  922.                      Code = emsActiveHandles(&Handles);
  923.                      if(Handles>0)printf("%d free handles\n",255-Handles);
  924.  
  925.          See Also    emsOwnedPages
  926.  
  927.  
  928.                              4.12 emsOwnedPages
  929.  
  930.  
  931.         Function:    Returns the number of pages owned by a handle.
  932.  
  933.           Syntax:    int emsOwnedPages(Handle,OwnedP)
  934.                      int Handle;     /* EMS handle */
  935.                      int OwnedP;     /* pointer to owned handles */
  936.  
  937.          Remarks:     The  emsOwnedPages()  function  gets  the  number  of
  938.                      handles owned by the specified EMS handle. The minimum
  939.                      value is one.
  940.  
  941.          Returns:    0x00: No error.
  942.                      0x80: Internal error in EMS software.
  943.                      0x81: Malfunction in EMS hardware.
  944.                      0x83: Invalid handle.
  945.                      0x84: Undefined function.
  946.  
  947.          Example:    /* report # owned pages */
  948.                      int Code;
  949.                      int Owned;
  950.                      int Handle;
  951.                      ...
  952.                      Code = emsOwnedPages(Handle,&Owned);
  953.                      printf("%d pages owned by handle %d\n",Owned);
  954.  
  955.          See Also    emsActiveHandles
  956.  
  957.  
  958.  
  959.  
  960.         EMS4C Users Manual                                     Page 16
  961.                              4.13 emsPageInfo
  962.  
  963.         Function:    Returns handles & pages for all handles
  964.  
  965.           Syntax:    int emsPageInfo(PagesP,ActiveP)
  966.                      int *PagesP;       /* pointer to array to hold info */
  967.                      int *ActiveP;      /* pointer to # active pages */
  968.  
  969.          Remarks:    The emsPageInfo() function fills a passed  array  with
  970.                      4-byte  entries  of  handles & page counts: Bytes 0 &1
  971.                      contain the EMS handle, while bytes 2 & 3 contain  the
  972.                      number   of  pages.  Be  sure  to  pass  an  array  of
  973.                      sufficient size to contain all  entries.
  974.  
  975.          Returns:    0x00: No error.
  976.                      0x80: Internal error in EMS software.
  977.                      0x81: Malfunction in EMS hardware.
  978.                      0x84: Undefined function.
  979.  
  980.          Example:    /* get page info */
  981.                      int Code;
  982.                      int Active;
  983.                      struct
  984.                      {int Handle;
  985.                       int Pages;
  986.                      } Array[255];
  987.                      ...
  988.                      Code = emsPageInfo(&Array,&Active);
  989.  
  990.  
  991.  
  992.  
  993.  
  994.  
  995.  
  996.  
  997.  
  998.  
  999.  
  1000.  
  1001.  
  1002.  
  1003.  
  1004.  
  1005.  
  1006.  
  1007.  
  1008.  
  1009.  
  1010.  
  1011.  
  1012.  
  1013.  
  1014.  
  1015.  
  1016.  
  1017.  
  1018.  
  1019.  
  1020.         EMS4C Users Manual                                     Page 17
  1021.                              4.14 emsPageMap
  1022.  
  1023.  
  1024.         Function:    Gets or sets EMS page-mapping registers.
  1025.  
  1026.           Syntax:    int emsPageMap(Function,SrcArray,DstArray,*Result)
  1027.                      int Function;        /* sub-function */
  1028.                      char SrcArray[];     /* pointer to source array */
  1029.                      char DstArray[];     /* pointer to dest. array */
  1030.                      int  *Result;        /* pointer to Result */
  1031.  
  1032.          Remarks:    The emsPageMap function is used to get or set page map
  1033.                      registers, or get the size of the Page Map array. This
  1034.                      function is  designed  to  support  multi-tasking  DOS
  1035.                      extenders such as Windows.
  1036.  
  1037.                      The  Result  variable  will contain the page map array
  1038.                      size  if  emsPageMap  was  called  successfully   with
  1039.                      sub-function 3.
  1040.  
  1041.                      The  emsPageMap  function  should  not  be  used   for
  1042.                      programs  other  than multi-tasking Operating Systems.
  1043.                      It is included in the EMS4C library  for  completeness
  1044.                      only.
  1045.  
  1046.                        Subfunction values are:
  1047.  
  1048.                        00H = Getting registers into array
  1049.                        01H = Setting registers from array
  1050.                        02H = Get and set operation
  1051.                        03H = Return size of page-mapping array
  1052.  
  1053.          Returns:    0x00: No error.
  1054.                      0x80: Internal error in EMS software.
  1055.                      0x81: Malfunction in EMS hardware.
  1056.                      0x84: Undefined function.
  1057.                      0x8f: Subfunction not defined.
  1058.  
  1059.          Example:    /* get size of page mapping array */
  1060.                      char SrcArray[], DstArray[];
  1061.                      int Result;
  1062.                      ...
  1063.                      Code = emsPageMap(3,SrcArray,DstArray,&Result);
  1064.                      if(Code==0) printf("Array size = %d\n",Result);
  1065.  
  1066.  
  1067.  
  1068.  
  1069.  
  1070.  
  1071.  
  1072.  
  1073.  
  1074.  
  1075.  
  1076.  
  1077.  
  1078.  
  1079.  
  1080.         EMS4C Users Manual                                     Page 18
  1081.          5.0 EMS Error Codes
  1082.  
  1083.  
  1084.          Be  sure and check the return codes from each EMS4C function call.
  1085.          There are 18 error codes returned by the EMS4C library other  than
  1086.          0  (no  error).   All  error  codes  are  negative numbers.  Their
  1087.          numerical values are the same  as  returned  from  the  MSDOS  EMS
  1088.          Driver (EMMXXXX0) and are defined in the EMS4C.H file.
  1089.  
  1090.                              EMS Error Codes
  1091.  
  1092.          **************************************************************
  1093.          *  0x00  *  No error.                                        *
  1094.          *  0x80  *  Internal error in EMS software.                  *
  1095.          *  0x81  *  Malfunction in EMS hardware.                     *
  1096.          *  0x83  *  Invalid handle.                                  *
  1097.          *  0x84  *  Undefined function.                              *
  1098.          *  0x85  *  No more handles available.                       *
  1099.          *  0x86  *  Error in mapping context.                        *
  1100.          *  0x87  *  Logical pages not available.                     *
  1101.          *  0x88  *  Logical pages not currently available.           *
  1102.          *  0x89  *  Zero pages requested.                            *
  1103.          *  0x8a  *  Logical page not assigned to this handle.        *
  1104.          *  0x8b  *  Physical page number invalid.                    *
  1105.          *  0x8c  *  Page-mapping hardware state save area full.      *
  1106.          *  0x8d  *  Mapping context already associated.              *
  1107.          *  0x8e  *  Save area has no context for handle.             *
  1108.          *  0x8f  *  Subfunction not defined.                         *
  1109.          *  0xa0  *  EMS driven not loaded.                           *
  1110.          *  0xa1  *  Illegal library modification. (Shareware only).  *
  1111.          *  0xa2  *  emsLoaded not called.                            *
  1112.          **************************************************************
  1113.  
  1114.  
  1115.  
  1116.  
  1117.  
  1118.  
  1119.  
  1120.  
  1121.  
  1122.  
  1123.  
  1124.  
  1125.  
  1126.  
  1127.  
  1128.  
  1129.  
  1130.  
  1131.  
  1132.  
  1133.  
  1134.  
  1135.  
  1136.  
  1137.  
  1138.  
  1139.  
  1140.         EMS4C Users Manual                                     Page 19
  1141.          6.0 Legal Issues
  1142.  
  1143.          6.1 Registration
  1144.  
  1145.  
  1146.          If you wish to register the EMS4C library, please send $35 plus $3
  1147.          S&H ($6 outside of North America) to:
  1148.  
  1149.                   MarshallSoft Computing, Inc.
  1150.                   Post Office Box  4543
  1151.                   Huntsville AL 35815
  1152.  
  1153.          We  accept  American  Express  (account  number,  expiration date,
  1154.          exact name  on  your  card,  and  complete  AmEx  billing  address
  1155.          required),  checks  in  US  dollars  drawn  on a US bank, purchase
  1156.          orders (POs) from recognized US schools and  companies  listed  in
  1157.          Dun  &  Bradstreet,  and  COD  (street  address  and  phone number
  1158.          required) within the USA (plus a $3 COD charge).  Print  the  file
  1159.          EMS4C.INV if an invoice is needed.
  1160.  
  1161.          You  can  also  order EMS4C from The Public Software Library (PSL)
  1162.          with your MC, Visa, AmEx, or Discover card by calling 800-242-4PSL
  1163.          (from overseas: 713-524-6394) or by  FAX  at  713-524-6398  or  by
  1164.          CompuServe  at  [71355,470].  THESE NUMBERS ARE FOR ORDERING ONLY.
  1165.          The product number for EMS4C is 10912.
  1166.  
  1167.          If  you  wish  to  update from an older version of EMS4C, send $15
  1168.          plus  $3  S&H  ($6 outside  of  North  America).  Updates  must be
  1169.          ordered directly from MarshallSoft Computing.
  1170.  
  1171.          The registered package includes:
  1172.  
  1173.          o  No shareware screen.
  1174.          o  Assembler source code for the library.
  1175.          o  Laser printed Users Manual.
  1176.          o  Telephone / FAX / BBS support for one year.
  1177.          o  The EMM4C library.
  1178.  
  1179.          Print  the  file EMS4C.INV if an invoice is needed. The registered
  1180.          user will receive the latest version of EMS4C shipped by  two  day
  1181.          priority  mail  (packet  airmail  overseas).   A 5.25" diskette is
  1182.          provided unless a 3.5" diskette is requested.
  1183.  
  1184.  
  1185.          6.2 Referral Program
  1186.  
  1187.  
  1188.          The registered user will receive  a  $5  certificate  towards  any
  1189.          MarshallSoft   Computing  product  by  referring  a  new  customer
  1190.          (someone who has never registered with us). The new customer  must
  1191.          identify  you at the time the order is placed.  You will be mailed
  1192.          a certificate worth $5 when the new registration is paid.
  1193.  
  1194.  
  1195.  
  1196.  
  1197.  
  1198.  
  1199.  
  1200.         EMS4C Users Manual                                     Page 20
  1201.          6.3 License
  1202.  
  1203.  
  1204.          MarshallSoft Computing, Inc. grants the registered user  of  EMS4C
  1205.          the  right  to  use  the  EMS4C  library  (in  object form) in the
  1206.          development  of  any  software  product  without  any   royalties.
  1207.          However,   the   source   code  (EMS4C.ASM)  for  the  library  is
  1208.          copyrighted by  MarshallSoft  Computing,  Inc.,  and  may  not  be
  1209.          released in whole or in part.
  1210.  
  1211.  
  1212.          6.4 Warranty
  1213.  
  1214.  
  1215.          MARSHALLSOFT COMPUTING, INC. DISCLAIMS ALL WARRANTIES RELATING  TO
  1216.          THIS  SOFTWARE,  WHETHER  EXPRESSED  OR IMPLIED, INCLUDING BUT NOT
  1217.          LIMITED TO ANY IMPLIED WARRANTIES OF MERCHANTABILITY  AND  FITNESS
  1218.          FOR  A  PARTICULAR  PURPOSE, AND ALL SUCH WARRANTIES ARE EXPRESSLY
  1219.          AND SPECIFICALLY DISCLAIMED. NEITHER MARSHALLSOFT COMPUTING,  INC.
  1220.          NOR ANYONE ELSE WHO HAS BEEN INVOLVED IN THE CREATION, PRODUCTION,
  1221.          OR  DELIVERY  OF  THIS  SOFTWARE SHALL BE LIABLE FOR ANY INDIRECT,
  1222.  
  1223.          CONSEQUENTIAL, OR INCIDENTAL DAMAGES ARISING OUT  OF  THE  USE  OR
  1224.          INABILITY  TO  USE  SUCH  SOFTWARE EVEN IF MARSHALLSOFT COMPUTING,
  1225.          INC.  HAS BEEN ADVISED OF  THE  POSSIBILITY  OF  SUCH  DAMAGES  OR
  1226.          CLAIMS. IN NO EVENT SHALL MARSHALLSOFT COMPUTING, INC.'S LIABILITY
  1227.          FOR ANY SUCH DAMAGES EVER EXCEED THE PRICE PAID FOR THE LICENSE TO
  1228.          USE  THE SOFTWARE, REGARDLESS OF THE FORM OF THE CLAIM. THE PERSON
  1229.          USING  THE  SOFTWARE  BEARS  ALL  RISK  AS  TO  THE  QUALITY   AND
  1230.          PERFORMANCE OF THE SOFTWARE.
  1231.  
  1232.          Some  states  do not allow the exclusion of the limit of liability
  1233.          for consequential or incidental damages, so the  above  limitation
  1234.          may not apply to you.
  1235.  
  1236.          This  agreement  shall  be  governed  by  the laws of the State of
  1237.          Alabama and shall inure to the benefit of Marshallsoft  Computing,
  1238.          Inc.   and  any successors, administrators, heirs and assigns. Any
  1239.          action or proceeding brought by either  party  against  the  other
  1240.          arising  out of or related to this agreement shall be brought only
  1241.          in a STATE or FEDERAL COURT of competent jurisdiction  located  in
  1242.          Madison County, Alabama. The parties hereby consent to in personam
  1243.          jurisdiction of said courts.
  1244.  
  1245.  
  1246.          7.0 Revision History
  1247.  
  1248.  
  1249.          Version 1.0 -- July 24, 1993 -- original release.
  1250.  
  1251.  
  1252.  
  1253.  
  1254.  
  1255.  
  1256.  
  1257.  
  1258.  
  1259.  
  1260.         EMS4C Users Manual                                     Page 21
  1261.          8.0 Other MarshallSoft Computing Products for C
  1262.  
  1263.  
  1264.          Shareware  versions  of  all  MarshallSoft  Computing products are
  1265.          available on our user support BBS 205-880-9748.
  1266.  
  1267.  
  1268.          8.1 The Personal Communications Library for C
  1269.  
  1270.  
  1271.          The Personal Communications Library for the C Language (PCL4C)  is
  1272.          an  asynchronous  communications  library designed for experienced
  1273.          software  developers  programming  in  C.   Four   compilers   are
  1274.          supported:  Microsoft  Optimizing  C,  Microsoft  Quick C, Borland
  1275.          Turbo C, and MIX Power  C.   An  IBM  PC/XT/AT  or  compatible  is
  1276.          required.  The PCL features:
  1277.  
  1278.          o SMALL, COMPACT, MEDIUM & LARGE memory models.
  1279.          o 33 communications and support functions.
  1280.          o Supports PC/4 and PC/8 Digiboard.
  1281.          o Support for the high performance INS16550 UART.
  1282.          o Supports hardware (RTS/CTS) flow control.
  1283.          o Interrupt driven receiver.
  1284.          o Supports 300 baud to 115,200 baud.
  1285.          o Supports COM1, COM2, COM3, and  COM4.
  1286.          o Adjustable receive queues from 8 bytes to 32 KB.
  1287.          o Control-BREAK error exit.
  1288.          o 17 communications error conditions trapped.
  1289.          o Allows 4 ports to run concurrently.
  1290.          o Complete modem control & status.
  1291.          o Written in assembly language for small size & high speed.
  1292.          o Terminal program featuring XMODEM, YMODEM, & YMODEM-G.
  1293.  
  1294.          The Personal Communications Library for C (PCL4C) is available for
  1295.          $55  plus  $3 S&H ($6 S&H overseas). It may be ordered at the same
  1296.          time as the Personal Protocol Library for $65 plus $3.50  S&H  ($7
  1297.          overseas).
  1298.  
  1299.  
  1300.          8.2 The Personal Protocol Library for C
  1301.  
  1302.  
  1303.          The  Personal  Protocol  Library  (PPL)  consist of a state driven
  1304.          library  which  implements  the  XMODEM,  XMODEM-CRC,   XMODEM-1K,
  1305.          XMODEM-G,  YMODEM,  and  YMODEM-G  file  transfer protocols.  This
  1306.          allows  the  programmer  to  run   multiple   protocol   transfers
  1307.          simultaneously while interacting with the user at the keyboard.
  1308.  
  1309.          The  Personal  Protocol Library for C (PPL4C) is available for $35
  1310.          plus $3 S&H ($6 S&H overseas). Both the Communications library and
  1311.          the Protocol library can be ordered together for $65.
  1312.  
  1313.          The PPL requires the Personal Protocol Library for  C  (PCL4C)  as
  1314.          described above.
  1315.  
  1316.  
  1317.  
  1318.  
  1319.  
  1320.         EMS4C Users Manual                                     Page 22
  1321.          8.3 The LZW Data Compression Library for C
  1322.  
  1323.          LZW4C is an implementation of the LZW (Lempel-Ziv-Welch) algorithm
  1324.          for compressing and decompressing  data.   LZW  does  particularly
  1325.          well on text files, achieving better than a 50 % compression ratio
  1326.          for many files.
  1327.  
  1328.          The  LZW  algorithm  is  considered  to be one of the best general
  1329.          purpose algorithms available today.  The  new  high  speed  modems
  1330.          that  employ  on-the-fly  data  compression (such as MNP 5.0 & the
  1331.          V.42 bis international standard) use the LZW algorithm, as well as
  1332.          such well known utility programs such as PKZIP.
  1333.  
  1334.          The  LZW  Data Compression Library for C is available for $35 plus
  1335.          $3 S&H ($6 S&H overseas).
  1336.  
  1337.  
  1338.  
  1339.  
  1340.  
  1341.  
  1342.  
  1343.  
  1344.  
  1345.  
  1346.  
  1347.  
  1348.  
  1349.  
  1350.  
  1351.  
  1352.  
  1353.  
  1354.  
  1355.  
  1356.  
  1357.  
  1358.  
  1359.  
  1360.  
  1361.  
  1362.  
  1363.  
  1364.  
  1365.  
  1366.  
  1367.  
  1368.  
  1369.  
  1370.  
  1371.  
  1372.  
  1373.  
  1374.  
  1375.  
  1376.  
  1377.  
  1378.  
  1379.  
  1380.         EMS4C Users Manual                                     Page 23
  1381.  
  1382.